import api from './index'
import type { ApiResponse } from './auth'
import { Cache } from '../utils/cache'

// 聊天会话类型定义
export interface Chat {
  ID: number;
  CreatedAt: string;
  UpdatedAt: string;
  DeletedAt: string | null;
  name: string;
  user_id: number;
  provider: string;
  ai_model: string;
  system_prompt?: string;
  description?: string;
  message_count: number;
  is_hide: number;
  last_message_at?: string;
}

// 创建聊天会话请求参数
export interface CreateChatRequest {
  systemFlag?: number;
  systemContext?: string;
  name?: string;
  roleId?: number | null;  // 允许null值
}

// 聊天消息类型定义
export interface ChatQuestionVO {
  role: string;      // 角色: user, assistant, system
  content: string;   // 消息内容
  timestamp: string; // 时间戳
}

// 发送消息请求参数
export interface SendMessageRequest {
  chat_id: number;    // 聊天ID
  content: string;    // 消息内容
  model?: string;     // 可选：指定使用的模型，如果不指定则使用聊天时选择的模型
  provider?: string;  // 可选：指定使用的AI提供商
}

// 模型信息接口
export interface ModelInfo {
  modelName: string;
}

// 缓存配置
const CACHE_KEYS = {
  CHAT_LIST: 'chat_list',
  CHAT_MESSAGES: 'chat_messages',
  MODEL_LIST: 'model_list',
  PROVIDER_LIST: 'provider_list', // 新增
  ROLE_LIST: 'role_list'
} as const;

// 缓存时间配置（毫秒）
const CACHE_EXPIRY = {
  CHAT_LIST: 2 * 60 * 1000, // 聊天列表缓存2分钟
  CHAT_MESSAGES: 5 * 60 * 1000, // 聊天消息缓存5分钟
  MODEL_LIST: 30 * 60 * 1000 // 模型列表缓存30分钟
} as const

// 创建新的聊天会话
export const createChat = async (params: CreateChatRequest): Promise<ApiResponse<Chat>> => {
  try {
    const result = await api.post<any, ApiResponse<Chat>>('/chat/add', params)
    if (result.code === 200) {
      Cache.remove(CACHE_KEYS.CHAT_LIST)
    }
    return result
  } catch (error) {
    console.error('创建聊天失败:', error)
    throw error
  }
}

// 获取聊天会话列表
export const getChatList = async (): Promise<ApiResponse<Chat[]>> => {
  // 尝试从缓存获取
  const cachedData = Cache.get<ApiResponse<Chat[]>>(CACHE_KEYS.CHAT_LIST)
  if (cachedData) {
    console.debug('使用缓存的聊天列表数据')
    return cachedData
  }

  try {
    const result = await api.get<any, ApiResponse<Chat[]>>('/chat/list')
    if (result.code === 200) {
      // 缓存结果
      Cache.set(CACHE_KEYS.CHAT_LIST, result, CACHE_EXPIRY.CHAT_LIST)
      
      // 检查聊天列表是否为空，如果为空则创建一个默认的新聊天
      // if (!result.data || result.data.length === 0) {
      //   return await createDefaultChat()
      // }
    }
    return result
  } catch (error) {
    console.error('获取聊天列表失败:', error)
    // 返回一个空数组但状态码仍为200，避免UI显示错误
    return {
      code: 200,
      msg: '获取聊天列表失败',
      data: []
    }
  }
}

// 创建默认聊天
// async function createDefaultChat(): Promise<ApiResponse<Chat[]>> {
//   try {
//     // 尝试创建一个默认聊天
//     const defaultChat = await createChat({
//       name: '新的对话',
//       systemContext: '你是一位智能助手，可以回答问题、编写代码和提供建议。',
//       systemFlag: 1
//     });
//
//     if (defaultChat.code === 200 && defaultChat.data) {
//       // 如果成功创建，返回包含这个新聊天的列表
//       return {
//         code: 200,
//         data: [defaultChat.data],
//         msg: '已创建新的对话'
//       };
//     } else {
//       // 如果创建失败，返回空列表
//       return {
//         code: 200,
//         data: [],
//         msg: '暂无聊天，请创建新的对话'
//       };
//     }
//   } catch (error) {
//     console.error('创建默认聊天失败:', error);
//     return {
//       code: 200,
//       data: [],
//       msg: '暂无聊天，请创建新的对话'
//     };
//   }
// }

// 删除聊天会话
export const deleteChat = async (chatId: number): Promise<ApiResponse<void>> => {
  // 删除操作后清除相关缓存
  const result = await api.delete<any, ApiResponse<void>>(`/chat/${chatId}`);
  if (result.code === 200) {
    Cache.remove(CACHE_KEYS.CHAT_LIST);
    Cache.remove(`${CACHE_KEYS.CHAT_MESSAGES}_${chatId}`);
  }
  return result;
}

// 根据对话ID获取消息列表
export const getChatMessages = async (chatId: number): Promise<ApiResponse<ChatQuestionVO[]>> => {
  const cacheKey = `${CACHE_KEYS.CHAT_MESSAGES}_${chatId}`;
  
  // 尝试从缓存获取
  const cachedData = Cache.get<ApiResponse<ChatQuestionVO[]>>(cacheKey);
  if (cachedData) {
    console.debug(`使用缓存的聊天消息数据，聊天ID: ${chatId}`);
    return cachedData;
  }

  try {
    // 缓存不存在或已过期，发起请求
    const result = await api.get<any, ApiResponse<ChatQuestionVO[]>>(`/chat/question/list?id=${chatId}`);
    if (result.code === 200) {
      // 缓存结果
      Cache.set(cacheKey, result, CACHE_EXPIRY.CHAT_MESSAGES);
      
      // 检查消息列表是否为空，如果为空则添加默认欢迎消息
      if (!result.data || result.data.length === 0) {
        return createDefaultWelcomeMessages();
      }
    }
    return result;
  } catch (error) {
    console.error('获取聊天消息失败:', error);
    // 网络错误或服务器错误时，返回默认欢迎消息
    return createDefaultWelcomeMessages();
  }
}

// 创建默认的欢迎消息
function createDefaultWelcomeMessages(): ApiResponse<ChatQuestionVO[]> {
  const now = new Date().toISOString();
  const welcomeMessages: ChatQuestionVO[] = [
    {
      role: 'system',
      content: '欢迎使用布丁AI助手，我可以帮您回答问题、编写代码、创作内容等。请告诉我您需要什么帮助？',
      timestamp: now
    },
    {
      role: 'assistant',
      content: '您好！我是布丁AI，很高兴为您服务。您可以直接向我提问，我会尽力为您提供帮助。以下是我可以做的一些事情：\n\n- 回答各类知识问题\n- 帮助编写和解释代码\n- 协助创作和润色文章\n- 提供学习和工作建议\n\n有什么我可以帮您的吗？',
      timestamp: now
    }
  ];
  
  return {
    code: 200,
    data: welcomeMessages,
    msg: '获取成功'
  };
}

// 发送消息
export const sendChatMessage = async (params: SendMessageRequest): Promise<ApiResponse<ChatQuestionVO>> => {
  // 发送消息后清除相关缓存
  const result = await api.post<any, ApiResponse<ChatQuestionVO>>('/chat/question/add', params);
  if (result.code === 200) {
    Cache.remove(`${CACHE_KEYS.CHAT_MESSAGES}_${params.chat_id}`);
  }
  return result;
}

// 获取可用的AI模型列表
// 供应商信息接口
export interface ProviderInfo {
  id: number;          // 改为小写，匹配后端JSON
  name: string;        // 改为小写
  logo: string;        // 改为小写
  describe: string;    // 改为describe，匹配后端JSON字段名
  models: string[];    // 改为小写
}

// 更新ModelInfo接口（如果需要保留）
export interface ModelInfo {
  modelName: string;
}

// 修改getModelList接口，改为获取供应商列表
// 修改getProviderList接口，使用正确的端点
export const getProviderList = async (): Promise<ApiResponse<ProviderInfo[]>> => {
  const cacheKey = CACHE_KEYS.PROVIDER_LIST;
  
  // 尝试从缓存获取
  const cachedData = Cache.get<ApiResponse<ProviderInfo[]>>(cacheKey);
  if (cachedData) {
    console.debug('使用缓存的供应商列表数据');
    return cachedData;
  }

  // 缓存不存在或已过期，发起请求
  // 使用正确的模型列表接口
  const result = await api.get<any, ApiResponse<ProviderInfo[]>>('/chat/model/list');
  if (result.code === 200) {
    // 缓存结果
    Cache.set(cacheKey, result, CACHE_EXPIRY.MODEL_LIST);
    console.debug('供应商列表数据已缓存');
  }
  return result;
};

// 保留原有的getModelList接口作为兼容（如果其他地方还在使用）
export const getModelList = async (agent: number = 1): Promise<ApiResponse<ModelInfo[]>> => {
  // 可以标记为废弃，建议使用getProviderList
  console.warn('getModelList is deprecated, use getProviderList instead');
  
  const cacheKey = `${CACHE_KEYS.MODEL_LIST}_${agent}`;
  
  const cachedData = Cache.get<ApiResponse<ModelInfo[]>>(cacheKey);
  if (cachedData) {
    console.debug(`使用缓存的模型列表数据，agent: ${agent}`);
    return cachedData;
  }

  const result = await api.get<any, ApiResponse<ModelInfo[]>>(`/chat/model/list?agent=${agent}`);
  if (result.code === 200) {
    Cache.set(cacheKey, result, CACHE_EXPIRY.MODEL_LIST);
    console.debug(`模型列表数据已缓存，agent: ${agent}`);
  }
  return result;
};

// 角色信息接口
export interface ChatAgentRole {
  id: number;
  name: string;
  icon: string;
  type: number;
  describe: string;
}

// 获取角色列表
export const getRoleList = async (): Promise<ApiResponse<ChatAgentRole[]>> => {
  try {
    const result = await api.get<any, ApiResponse<ChatAgentRole[]>>('/chat/roleList')
    return result
  } catch (error) {
    console.error('获取角色列表失败:', error)
    throw error
  }
}